﻿#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

template<class T>
class Stack
{
public:
    Stack(size_t capacity=4)
    {
        _array = new T[capacity];
        _capacity = capacity;
        _top = 0;
    }
    //声明
    void push(const T& data);
private:
    T* _array;
    size_t _capacity;
    size_t _top;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
//template<class T>
//void Stack<T>::push(const T& data)
//{
//    if (_capacity == _top)//容量满了就扩容
//    {
//        T* tmp = new T[2 * _capacity];
//        _capacity *= 2;//更新容量
//        memcpy(tmp, _array, _top*sizeof(T));//把数据拷贝到新空间
//        delete _array;//释放旧空间
//        _array = tmp;//让_array指向新空间
//        //临时变量tmp出作用域后自动销毁
//    }
//    _array[_top++] = data;
//}
template<class X>
void Stack<X>::push(const X& data)
{
    if (_capacity == _top)//容量满了就扩容
    {
        X* tmp = new X[2 * _capacity];
        _capacity *= 2;//更新容量
        memcpy(tmp, _array, _top * sizeof(X));//把数据拷贝到新空间
        delete _array;//释放旧空间
        _array = tmp;//让_array指向新空间
        //临时变量tmp出作用域后自动销毁
    }
    _array[_top++] = data;
}

int main()
{
    Stack<int> st(4);
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);
    st.push(5);
    st.push(6);
    st.push(7);
    st.push(8);
    st.push(9);
    return 0;
}

#if 0
class A
{
public:
private:
    int _a1 = 1;
    int _a2 = 1;
};

class B
{
public:
    ~B()
    {}
private:
    int _B1 = 2;
    int _B2 = 2;
};

//void Swap(int& left, int& right)
//{
//    int temp = left;
//    left = right;
//    right = temp;
//}
//void Swap(double& left, double& right)
//{
//    double temp = left;
//    left = right;
//    right = temp;
//}
//void Swap(char& left, char& right)
//{
//    char temp = left;
//    left = right;
//    right = temp;
//}
//......

//template<typename T>
template<class T>
void Swap(T& left, T& right)
{
    T tmp = left;
    left = right;
    right = tmp;
}

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
int main()
{
    int a = 10;
    int* b = nullptr;
    // 显式实例化
    //Add<int>(a, b);//指针类型无法隐式类型转化为int，直接报错
    return 0;
}

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}

// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
    return left + right;
}

void Test()
{
    Add(1, 2);// 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0);// 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

// 专门处理int的加法函数
//int Add(int left, int right)
//{
//    return left + right;
//}
//
// 通用加法函数
//template<class T>
//T Add(T left, T right)
//{
//    return left + right;
//}
//
//void Test()
//{
//    Add(1, 2);       // 与非模板函数匹配，编译器不需要特化
//    Add<int>(1, 2);  // 调用编译器特化的Add版本
//}


int main1()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, (int)d1);//强制类型转化
    Add<int>(a1, d1);//显示实例化
    Add(a1, a2);
    Add(d1, d2);
    return 0;
}

        

int main3()
{
    double d1 = 1.1, d2 = 2.2;
    Swap(d1, d2);

    return 0;
}

int main2()
{
    //运行时不崩溃
  /*  A* p1 = new A[10];
    delete p1;*/
    //运行时崩溃
    B* p2 = new B[10];
    delete p2;
    return 0;
}
int GetMonthDay(int year, int month)
{
    static int n[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    if ((month == 2) &&
        ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
    {
        return 29;
    }//是闰年
    return n[month];
}
int main1()
{
    int year = 0;
    int day = 0;

    while (scanf("%d%d", &year, &day) != EOF)
    {
        int n = 1;
        int _day = 1;
        int _month = 1;
        while (n != day)
        {
            if (_day == GetMonthDay(year, _month))
            {
                _day = 0;
                _month++;
            }
            _day++;
            n++;
        }
        printf("%04d-%02d-%02d\n", year, _month, _day);
    }
    return 0;
}
#endif